﻿using System;
using System.Collections.Generic;
using System.Configuration;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Transactions;
using System.Web;
using SPMS.Data;

namespace SPMS.Common
{
    /// <summary>
    /// 文件上传辅助类。
    /// </summary>
    public class FileUploadHelper
    {
        #region ---Public Method

        /// <summary>
        /// 上传临时文件。
        /// </summary>
        /// <param name="sessionID">当前会话编号。</param>
        /// <param name="request">文件上传请求。</param>
        /// <param name="fileProcess">文件处理器。</param>
        /// <returns>
        /// 临时文件编号。
        /// </returns>
        /// <exception cref="BusinessException"></exception>
        /// <exception cref="SPMS.Common.BusinessException"></exception>
        public static Guid[] UploadTempFile(Guid sessionID, HttpRequestBase request, Func<Stream, object, Stream> fileProcess = null, object state = null)
        {
            //判断是否有需要上传文件
            if (null == request || request.Files.Count == 0)
            {
                //如果没有文件上传，则返回空数组
                return new Guid[0];
            }

            //用于保存临时文件编号
            List<TempFile> tempFiles = new List<TempFile>();

            //获得存储路径
            string repositoryPath = GetTempFileRepositoryPath();

            //用于保存临时文件信息
            TempFile tempFile = null;

            //打开实体上下文
            using (AccountFileManagementEntities context = new AccountFileManagementEntities())
            {
                //启动事务
                using (TransactionScope transaction = new TransactionScope())
                {
                    try
                    {
                        //循环上传临时文件
                        for (int index = 0; index < request.Files.Count; index++)
                        {
                            //添加临时文件
                            tempFile = AppendTempFile(context, sessionID, request.Files[index], repositoryPath, fileProcess, state);

                            //保存临时文件信息
                            tempFiles.Add(tempFile);
                        }

                        //提交数据
                        context.SaveChanges();

                        //提交事务
                        transaction.Complete();
                    }
                    catch (Exception ex)
                    {
                        //删除临时文件
                        ClearTempFiles(tempFiles);

                        //抛出异常
                        throw new BusinessException(SPMS.Common.Properties.Resources.text_error_save_tempfile, ex);
                    }
                }
            }

            //返回数据
            return tempFiles.Select(item => item.TempFile_ID).ToArray();
        }

        /// <summary>
        /// 获得临时文件存储路径。
        /// </summary>
        /// <returns>临时文件存储路径。</returns>
        public static string GetTempFileRepositoryPath()
        {
            //判断路径是否已经初始化
            if (string.IsNullOrEmpty(s_TempFilesRepositoryPath))
            {
                //获得临时路径
                string repositoryPath = ConfigurationManager.AppSettings[KEY_REPOSITORY_TEMPFILES];

                //判断是否配置了临时存储路径
                if (string.IsNullOrEmpty(repositoryPath))
                {
                    //抛出异常
                    throw new BusinessException(SPMS.Common.Properties.Resources.text_error_tempfiles_repository_notfound);
                }

                //生成绝对路径
                repositoryPath = IOHelper.MakePathRooted(repositoryPath);

                //判断临时存储路径是否存在
                if (!Directory.Exists(repositoryPath))
                {
                    try
                    {
                        //创建文件夹
                        Directory.CreateDirectory(repositoryPath);
                    }
                    catch (Exception ex)
                    {
                        //抛出异常
                        throw new BusinessException(SPMS.Common.Properties.Resources.text_error_tempfiles_repository_create_failed, ex);
                    }

                }

                //保存临时文件存储路径
                s_TempFilesRepositoryPath = repositoryPath;
            }

            //返回路径
            return s_TempFilesRepositoryPath;
        }

        /// <summary>
        /// 获得文件存储路径。
        /// </summary>
        /// <returns>文件存储路径。</returns>
        public static string GetRepositoryPath()
        {
            //判断路径是否已经初始化
            if (string.IsNullOrEmpty(s_RepositoryPath))
            {
                //获得临时路径
                string repositoryPath = ConfigurationManager.AppSettings[KEY_REPOSITORY];

                //判断是否配置了临时存储路径
                if (string.IsNullOrEmpty(repositoryPath))
                {
                    //抛出异常
                    throw new BusinessException(SPMS.Common.Properties.Resources.text_error_repository_notfound);
                }

                //生成绝对路径
                repositoryPath = IOHelper.MakePathRooted(repositoryPath);

                //判断临时存储路径是否存在
                if (!Directory.Exists(repositoryPath))
                {
                    try
                    {
                        //创建文件夹
                        Directory.CreateDirectory(repositoryPath);
                    }
                    catch (Exception ex)
                    {
                        //抛出异常
                        throw new BusinessException(SPMS.Common.Properties.Resources.text_error_repository_create_failed, ex);
                    }

                }

                //保存临时文件存储路径
                s_RepositoryPath = repositoryPath;
            }

            //返回路径
            return s_RepositoryPath;
        }

        /// <summary>
        /// 获得临时图片。
        /// </summary>
        /// <param name="tempFileID">临时文件编号。</param>
        /// <param name="width">图片的高度。</param>
        /// <param name="height">图片的宽度。</param>
        /// <param name="format">图片的格式。</param>
        /// <returns>
        /// 临时文件图片数据。
        /// </returns>
        public static byte[] GetTempImage(Guid tempFileID, int? width, int? height, ImageFormat format)
        {
            //创建数据上下文
            using (AccountFileManagementEntities context = new AccountFileManagementEntities())
            {
                //检索临时文件对象
                TempFile entity = context.TempFiles.FirstOrDefault(item => item.TempFile_ID == tempFileID);

                //判断临时文件是否存在
                if (null == entity)
                {
                    //如果不存在，则返回空
                    return null;
                }

                //获得临时文件名称
                string tempFileName = MakeTempFileName(tempFileID);

                //获得临时文件路径
                string tempFilePath = Path.Combine(GetTempFileRepositoryPath(), tempFileName);

                //判断文件是否存在
                if (!System.IO.File.Exists(tempFilePath))
                {
                    //如果不存在，则返回空
                    return null;
                }

                //判断是否需要处理图片
                if (width.HasValue || height.HasValue || null == format)
                {
                    //用于保存宽度
                    int imgWidth = 0;

                    //判断是否指定了宽度
                    if (width.HasValue)
                    {
                        imgWidth = width.Value;
                    }

                    //用于保存高度
                    int imgHeight = 0;

                    //判断是否指定了高度
                    if (height.HasValue)
                    {
                        imgHeight = height.Value;
                    }

                    //用于保存格式
                    ImageFormat imgFormat = ImageFormat.Jpeg;

                    //判断是否指定了格式
                    if (null != format)
                    {
                        imgFormat = format;
                    }

                    //创建位图
                    using (Bitmap source = (Bitmap)Bitmap.FromFile(tempFilePath))
                    {
                        //处理图片
                        using (Bitmap image = ProcessImage(source, imgWidth, imgHeight, 0, imgFormat, Color.White))
                        {
                            //创建内存流
                            using (MemoryStream stream = new MemoryStream())
                            {
                                //保存图片
                                image.Save(stream, imgFormat);

                                //返回图片数据
                                return stream.ToArray();
                            }
                        }
                    }
                }
                else
                {
                    //返回图片数据
                    using (FileStream stream = new FileStream(tempFilePath, FileMode.Open, FileAccess.Read))
                    {
                        //创建内存流
                        using (MemoryStream tempStream = new MemoryStream())
                        {
                            //保存图片
                            stream.CopyTo(tempStream);

                            //返回图片数据
                            return tempStream.ToArray();
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 将指定编号的临时文件拷贝为指定目标文件。
        /// </summary>
        /// <param name="context">数据上下文。</param>
        /// <param name="tempFileID">要移动的临时文件编号。</param>
        /// <param name="destFilePath">目标文件路径。</param>
        /// <exception cref="System.IO.FileNotFoundException"></exception>
        public static void CopyTempFileTo(AccountFileManagementEntities context, Guid tempFileID, string destFilePath)
        {
            //删除临时文件
            string tempFilePath = RemoveTempFile(context, tempFileID);

            //移动文件
            File.Copy(tempFilePath, destFilePath, true);
        }

        /// <summary>
        /// 删除临时文件。
        /// </summary>
        /// <param name="tempFileID">要删除的临时文件编号。</param>
        public static void DeleteTempFile(Guid tempFileID)
        {
            //获得临时文件名称
            string tempFileName = MakeTempFileName(tempFileID);

            //删除文件
            IOHelper.SafeDeleteFile(tempFileName);
        }

        /// <summary>
        /// 将指定编号的临时文件拷贝为指定图片文件。
        /// </summary>
        /// <param name="context">数据上下文。</param>
        /// <param name="tempFileID">要移动的临时文件编号。</param>
        /// <param name="width">目标图片宽度。</param>
        /// <param name="height">目标图片高度。</param>
        /// <param name="rotationAngle">旋转角度。</param>
        /// <param name="format">目标图片的格式。</param>
        /// <param name="destFilePath">目标图片文件路径。</param>
        /// <exception cref="System.IO.FileNotFoundException"></exception>
        public static void CopyTempFileToImage(AccountFileManagementEntities context, Guid tempFileID, int width, int height, float rotationAngle, ImageFormat format, string destFilePath, bool isCreateThumb = true)
        {
            //删除临时文件
            string tempFilePath = RemoveTempFile(context, tempFileID);

            //创建位图
            using (Bitmap source = (Bitmap)Bitmap.FromFile(tempFilePath))
            {
                //处理图片
                using (Bitmap image = ProcessImage(source, width, height, 0, format, Color.White))
                {
                    //判断是否生成缩略图
                    if (isCreateThumb)
                    {
                        //获得缩略图路径
                        string thumbFilePath = MakeThumbFilePath(destFilePath);

                        //生成缩略图
                        CreateThumbnails(image, thumbFilePath);
                    }

                    //准备路径
                    IOHelper.PrepareFilePath(destFilePath);

                    //生成文件
                    image.Save(destFilePath, format);
                }
            }
        }

        /// <summary>
        /// 将指定编号的临时文件转换为图片。
        /// </summary>
        /// <param name="context">数据上下文。</param>
        /// <param name="tempFileID">要移动的临时文件编号。</param>
        /// <param name="width">目标图片宽度。</param>
        /// <param name="height">目标图片高度。</param>
        /// <param name="rotationAngle">旋转角度。</param>
        /// <param name="format">目标图片的格式。</param>
        /// <param name="backgroundColor">背景颜色。</param>
        /// <returns>图片数据。</returns>
        /// <exception cref="System.IO.FileNotFoundException"></exception>
        public static byte[] ConvertTempFileToImage(AccountFileManagementEntities context, Guid tempFileID, int width, int height, float rotationAngle, ImageFormat format, Color backgroundColor)
        {
            //删除临时文件
            string tempFilePath = RemoveTempFile(context, tempFileID);

            //创建位图
            using (Bitmap source = (Bitmap)Bitmap.FromFile(tempFilePath))
            {
                //处理图片
                using (Bitmap image = ProcessImage(source, width, height, 0, format, backgroundColor))
                {
                    //创建内存流
                    using (MemoryStream stream = new MemoryStream())
                    {
                        //保存图片
                        image.Save(stream, format);

                        //返回图片数据
                        return stream.ToArray();
                    }
                }
            }
        }

        /// <summary>
        /// 生成指定图片文件的缩略图。
        /// </summary>
        /// <param name="sourceFilePath">要生成缩略图的图片文件路径。</param>
        /// <param name="destFilePath">缩略图的存储路径。</param>
        public static void CreateThumbnails(string sourceFilePath, string destFilePath)
        {
            //创建位图
            using (Bitmap source = (Bitmap)Bitmap.FromFile(sourceFilePath))
            {
                //创建缩略图
                CreateThumbnails(source, destFilePath);
            }
        }

        /// <summary>
        /// 生成指定图片文件的缩略图。
        /// </summary>
        /// <param name="sourceFilePath">要生成缩略图的位图对象。</param>
        /// <param name="destFilePath">缩略图的存储路径。</param>
        public static void CreateThumbnails(Bitmap source, string destFilePath)
        {
            //判断源图片是否有效
            if (null == source)
            {
                //抛出异常
                throw new ArgumentNullException("source");
            }

            //处理图片
            using (Bitmap thumbnails = ProcessImage(source, THUMBNAILS_WIDTH, THUMBNAILS_HEIGHT, 0, THUMBNAILS_FORMAT, Color.White))
            {
                //准备路径
                IOHelper.PrepareFilePath(destFilePath);

                //生成文件
                thumbnails.Save(destFilePath, THUMBNAILS_FORMAT);
            }
        }

        /// <summary>
        /// 处理图片。
        /// </summary>
        /// <param name="source">要处理的目标图片。</param>
        /// <param name="width">目标图片宽度。</param>
        /// <param name="height">目标图片高度。</param>
        /// <param name="rotationAngle">旋转角度。</param>
        /// <param name="format">目标图片的格式。</param>
        /// <returns>
        /// 处理完毕的图片数据。
        /// </returns>
        public static Bitmap ProcessImage(Bitmap source, int width, int height, float rotationAngle, ImageFormat format, Color backgroundColor)
        {
            //判断源图片是否有效
            if (null == source)
            {
                //抛出异常
                throw new ArgumentNullException("source");
            }

            //记录是否需要转换
            bool needConvert = false;

            //用于保存X方向偏移值
            double dx = 0.0d;

            //用于保存Y方向偏移值
            double dy = 0.0d;

            //用于保存图片宽度
            int imageWidth = source.Width;

            //用于保存图片高度
            int imageHeight = source.Height;

            //调整角度，确保角度范围为0~360度
            rotationAngle = rotationAngle % 360;

            //判断是否小于0
            if (rotationAngle < 0)
            {
                //确保角度不小于0
                rotationAngle += 360;
            }

            //判断是否需要旋转图片
            if (rotationAngle > 0)
            {
                //计算弧度
                double radians = Math.PI / 180.0 * rotationAngle;

                //计算输出图片宽度
                double targetWidth = imageWidth * Math.Abs(Math.Cos(radians)) + imageHeight * Math.Abs(Math.Sin(radians));

                //计算输出图片高度
                double targetHeight = imageWidth * Math.Abs(Math.Sin(radians)) + imageHeight * Math.Abs(Math.Cos(radians));

                //计算偏移值
                if (radians < Math.PI / 2.0)
                {
                    dy = 0;
                    dx = Math.Abs(imageHeight * Math.Sin(radians));
                }
                else if (radians >= Math.PI / 2.0 && radians <= Math.PI)
                {
                    dy = Math.Abs(imageHeight * Math.Cos(radians));
                    dx = targetWidth;
                }
                else if (radians > Math.PI && radians <= Math.PI / 2 * 3)
                {
                    dy = targetHeight;
                    dx = Math.Abs(imageWidth * Math.Cos(radians));
                }
                else if (radians > Math.PI / 2 * 3)
                {
                    dy = Math.Abs(imageWidth * Math.Sin(radians));
                    dx = 0;
                }

                //调整输出图片高度
                imageWidth = (int)targetWidth;

                //调整输出图片高度
                imageHeight = (int)targetHeight;

                //设置需要转换
                needConvert = true;
            }

            //判断是否需要缩放
            if (imageWidth > width || imageHeight > height)
            {
                //计算图片的高宽比例
                double xRadio = imageWidth * 1.0 / width;
                double yRadio = imageHeight * 1.0 / height;

                //获得最终的比例
                double radio = Math.Max(xRadio, yRadio);

                //计算图片的最终高度
                width = (int)Math.Floor(imageWidth / radio);
                height = (int)Math.Floor(imageHeight / radio);

                //设置图片输出高宽
                imageWidth = (int)Math.Floor(source.Width / radio);
                imageHeight = (int)Math.Floor(source.Height / radio);

                //计算图片的最终偏移值
                dx = dx / radio;
                dy = dy / radio;

                //设置为需要转换
                needConvert = true;
            }
            else
            {
                //计算图片的宽度
                width = imageWidth;
                //计算图片的高度
                height = imageHeight;

                //设置图片输出高宽
                imageWidth = source.Width;
                imageHeight = source.Height;
            }

            //判断是否需要转换格式
            if (source.RawFormat != format)
            {
                //设置为需要转换
                needConvert = true;
            }

            //判断是否需要处理图片
            if (needConvert)
            {
                //创建图片
                System.Drawing.Bitmap destImage = new System.Drawing.Bitmap(width, height);

                //创建绘图对象
                using (System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(destImage))
                {
                    //设置差值算法
                    g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;

                    //设置高质量,低速度呈现平滑程度
                    g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;

                    //清空画布并填充背景色 
                    g.Clear(backgroundColor);

                    //判断是否旋转图片
                    if (rotationAngle > 0)
                    {
                        //偏移图片
                        g.TranslateTransform((int)dx, (int)dy);

                        //旋转图片
                        g.RotateTransform(rotationAngle);
                    }

                    //绘制图片
                    g.DrawImage(source, new System.Drawing.Rectangle(0, 0, imageWidth, imageHeight), 0, 0, source.Width, source.Height, System.Drawing.GraphicsUnit.Pixel);

                    //返回目标图片
                    return destImage;
                }
            }
            else
            {
                //返回原始图片
                return source;
            }
        }

        /// <summary>
        /// 获得指定图片格式的扩展名。
        /// </summary>
        /// <param name="format">图片格式。</param>
        public static string GetImageExtension(ImageFormat format)
        {
            if (format == ImageFormat.Jpeg)
            {
                return ".jpeg";
            }
            else if (format == ImageFormat.Bmp)
            {
                return ".bmp";
            }
            else if (format == ImageFormat.Emf)
            {
                return ".emf";
            }
            else if (format == ImageFormat.Exif)
            {
                return ".jpeg";
            }
            else if (format == ImageFormat.Gif)
            {
                return ".gif";
            }
            else if (format == ImageFormat.Icon)
            {
                return ".ico";
            }
            else if (format == ImageFormat.MemoryBmp)
            {
                return ".bmp";
            }
            else if (format == ImageFormat.Png)
            {
                return ".png";
            }
            else if (format == ImageFormat.Tiff)
            {
                return ".tif";
            }
            else if (format == ImageFormat.Wmf)
            {
                return ".wmf";
            }
            else
            {
                return ".jpeg";
            }
        }

        /// <summary>
        /// 获得指定图片格式的MIME类型。
        /// </summary>
        /// <param name="format">图片格式。</param>
        public static string GetImageMIME(ImageFormat format)
        {
            if (format == ImageFormat.Jpeg)
            {
                return SPMS.Common.Properties.Resources.text_content_type_jpeg;
            }
            else if (format == ImageFormat.Bmp)
            {
                return SPMS.Common.Properties.Resources.text_content_type_bmp;
            }
            else if (format == ImageFormat.Emf)
            {
                return SPMS.Common.Properties.Resources.text_content_type_emf;
            }
            else if (format == ImageFormat.Exif)
            {
                return SPMS.Common.Properties.Resources.text_content_type_jpeg;
            }
            else if (format == ImageFormat.Gif)
            {
                return SPMS.Common.Properties.Resources.text_content_type_gif;
            }
            else if (format == ImageFormat.Icon)
            {
                return SPMS.Common.Properties.Resources.text_content_type_icon;
            }
            else if (format == ImageFormat.MemoryBmp)
            {
                return SPMS.Common.Properties.Resources.text_content_type_bmp;
            }
            else if (format == ImageFormat.Png)
            {
                return SPMS.Common.Properties.Resources.text_content_type_png;
            }
            else if (format == ImageFormat.Tiff)
            {
                return SPMS.Common.Properties.Resources.text_content_type_tiff;
            }
            else if (format == ImageFormat.Wmf)
            {
                return SPMS.Common.Properties.Resources.text_content_type_wmf;
            }
            else
            {
                return SPMS.Common.Properties.Resources.text_content_type_binary;
            }
        }

        /// <summary>
        /// 根据图片格式名称获得图片格式。
        /// </summary>
        /// <param name="format">图片格式名称。</param>
        /// <param name="defaultFormat">默认图片格式。</param>
        /// <returns>
        /// 图片格式。
        /// </returns>
        public static ImageFormat GetImageFormat(string format, ImageFormat defaultFormat)
        {
            //判断是否指定了图片格式
            if (string.IsNullOrEmpty(format))
            {
                //没有指定，则返回空
                return defaultFormat;
            }

            //根据图片格式名称获得图片格式
            switch (format.ToLower())
            {
                case "jpeg":
                    return ImageFormat.Jpeg;
                case "bmp":
                    return ImageFormat.Bmp;
                case "emf":
                    return ImageFormat.Emf;
                case "gif":
                    return ImageFormat.Gif;
                case "icon":
                    return ImageFormat.Icon;
                case "png":
                    return ImageFormat.Png;
                case "wmf":
                    return ImageFormat.Wmf;
                default:
                    return defaultFormat;

            }
        }

        #endregion

        #region ---Private Method

        /// <summary>
        /// 删除临时文件。
        /// </summary>
        /// <param name="context">数据上下文。</param>
        /// <param name="tempFileID">要删除的临时文件编号。</param>
        /// <returns>临时文件路径。</returns>
        private static string RemoveTempFile(AccountFileManagementEntities context, Guid tempFileID)
        {
            //检索临时文件对象
            TempFile entity = context.TempFiles.FirstOrDefault(item => item.TempFile_ID == tempFileID);

            //判断临时文件是否存在
            if (null == entity)
            {
                //如果不存在，则抛出异常
                throw new FileNotFoundException(SPMS.Common.Properties.Resources.text_error_tempfile_notfound);
            }

            //获得临时文件名称
            string tempFileName = MakeTempFileName(tempFileID);

            //获得临时文件路径
            string tempFilePath = Path.Combine(GetTempFileRepositoryPath(), tempFileName);

            //判断文件是否存在
            if (!File.Exists(tempFilePath))
            {
                //如果不存在，则抛出异常
                throw new FileNotFoundException(SPMS.Common.Properties.Resources.text_error_tempfile_notfound);
            }

            //删除临时文件
            context.TempFiles.Remove(entity);

            //返回文件路径
            return tempFilePath;
        }

        /// <summary>
        /// 根据指定的临时文件编号，生成临时文件名称。
        /// </summary>
        /// <param name="tempFileID">临时文件编号。</param>
        /// <returns>临时文件名称。</returns>
        private static string MakeTempFileName(Guid tempFileID)
        {
            //生成文件名称
            return string.Format("{0:B}.tmp", tempFileID);
        }

        /// <summary>
        /// 根据指定的图片路径，生成缩略图文件路径。
        /// </summary>
        /// <param name="tempFileID">临时文件编号。</param>
        /// <returns>临时文件名称。</returns>
        private static string MakeThumbFilePath(string imageFilePath)
        {
            //获得文件扩展名
            string extension = Path.GetExtension(imageFilePath);

            //判断是否有扩展名
            if (string.IsNullOrEmpty(extension))
            {
                //生成文件路径
                return Path.Combine(Path.GetDirectoryName(imageFilePath), string.Format("{0}_thumb", Path.GetFileNameWithoutExtension(imageFilePath)));
            }
            else
            {
                //生成文件路径
                return Path.Combine(Path.GetDirectoryName(imageFilePath), string.Format("{0}_thumb{1}", Path.GetFileNameWithoutExtension(imageFilePath), extension));
            }
        }

        /// <summary>
        /// 清除指定的临时文件。
        /// </summary>
        /// <param name="tempFiles">要清除的临时文件列表。</param>
        private static void ClearTempFiles(ICollection<TempFile> tempFiles)
        {
            //循环删除文件
            foreach (TempFile item in tempFiles)
            {
                //删除文件
                IOHelper.SafeDeleteFile(item.TempFile_Path);
            }
        }

        /// <summary>
        /// 添加临时文件。
        /// </summary>
        /// <param name="context">数据上下文。</param>
        /// <param name="sessionID">会话编号。</param>
        /// <param name="file">上传的文件内容。</param>
        /// <param name="repositoryPath">文件存储路径。</param>
        /// <param name="fileProcess">文件处理器。</param>
        /// <returns>
        /// 临时文件编号。
        /// </returns>
        private static TempFile AppendTempFile(AccountFileManagementEntities context, Guid sessionID, HttpPostedFileBase file, string repositoryPath, Func<Stream, object, Stream> fileProcess = null, object state = null)
        {
            //生成临时文件编号
            Guid tempFileID = Guid.NewGuid();

            //生成临时文件名称
            string tempFileName = MakeTempFileName(tempFileID);

            //生成临时文件路径
            string tempFilePath = Path.Combine(repositoryPath, tempFileName);

            //创建实体
            TempFile entity = new TempFile()
            {
                Session_ID = sessionID,
                TempFile_ID = tempFileID,
                TempFile_Name = Path.GetFileName(file.FileName),
                TempFile_Path = tempFilePath,
                TempFile_Type = Path.GetExtension(file.FileName)
            };

            //保存临时文件
            using (FileStream stream = new FileStream(tempFilePath, FileMode.CreateNew, FileAccess.Write, FileShare.None))
            {
                //判断是否指定了文件处理器
                if (null != fileProcess)
                {
                    //处理文件
                    using (Stream tempStream = fileProcess(file.InputStream, state))
                    {
                        //写入文件内容
                        file.InputStream.CopyTo(stream);
                    }
                }
                else
                {
                    //写入文件内容
                    file.InputStream.CopyTo(stream);
                }

                //写入文件内容
                stream.Flush();
            }

            //添加实体
            context.TempFiles.Add(entity);

            //返回文件编号
            return entity;
        }

        #endregion

        #region ---Const

        /// <summary>
        /// 临时文件存储路径键值
        /// </summary>
        private const string KEY_REPOSITORY_TEMPFILES = "Repository_TempFiles";

        /// <summary>
        /// 文件存储路径键值
        /// </summary>
        private const string KEY_REPOSITORY = "Repository";

        /// <summary>
        /// 临时文件存储路径
        /// </summary>
        private static string s_TempFilesRepositoryPath = null;

        /// <summary>
        /// 文件存储路径
        /// </summary>
        private static string s_RepositoryPath = null;

        /// <summary>
        /// 缩略图的宽度。
        /// </summary>
        private const int THUMBNAILS_WIDTH = 64;

        /// <summary>
        /// 缩略图的高度。
        /// </summary>
        private const int THUMBNAILS_HEIGHT = 64;

        /// <summary>
        /// 缩略图的格式。
        /// </summary>
        private static readonly ImageFormat THUMBNAILS_FORMAT = ImageFormat.Jpeg;

        #endregion
    }
}
